perm filename NUMBER.RNM[VLI,LSP] blob
sn#382040 filedate 1978-09-08 generic text, type T, neo UTF8
.COMMENT ---------- Manuel VLISP 10 . 3 ----- Standard -----
.PAGE SIZE 55,68 ! 55 a cause de la VERSATEX
.CONTROL CHARACTERS
.FLAG QUOTE ←←
.FLAG CAPITALIZE ←|
.FLAG CONTROL ←.
.FLAG ENDFOOTNOTE ←!
.FLAG INDEX ←}
.NO FLAG LOWERCASE
.FLAG SPACE ←#
.NO FLAG SUBINDEX
.NO FLAG UNDERLINE
.NO FLAG UPPERCASE
.FIRST TITLE
.VARIABLE PART > <
.COMMENT ---------- Manuel VLISP 10 . 3 ----- Standard -----
.NUMBER CHAPTER 4
.CH Les nombres
.TITLE VLISP 10 . 3 Manuel de Reference
.FIRST TITLE
.LM 0
VLISP possede deux types de nombres : les nombres entiers et les nombres
flottants.
Ils sont stockes dans une zone de longeur fixe geree dynamiquement.
Si cette zone se revele trop petite, le message d'erreur suivant
apparait :
.BR
###}**← no← room← for← numbers.
.BR
Cette erreur est fatale. Il faut augmenter la taille de la
zone allouee aux nombres (dans la fonctions CONFIGURATION du
fichier initial CONFIG.INI) et relancer le travail.
.B 1
.B 1
Si durant un calcul, une exception arithmetique se produit, une erreur
apparait, avec comme libelle :
.BR
###}**← arithmetic← exception.← PC← :← <pc>
.BR
dans lequel <pc> est la valeur du }Program← Control.
Ce PC contient en partie droite la valeur du compteur
ordinal de l'instruction ayant provoquee l'interruption et
en partie gauche l'etat des indicateurs (en particulier
les indicateurs }debordement← d'entier , }debordement← flottant ,
}division← par← 0 ... cf: SYSTEM REF. MANUAL pg. 2-58
pour avoir une description complete de ces indicateurs).
.B 1
Certaines fonctions (les fonctions de conversion, les fonctions
de l'arithmetique mixte et les fonctions
de comparaison mixte) testent si
leur(s) argument(s) sont des nombres. Dans le cas ou ils ne
le seraient pas, une erreur apparait. Le libelle de cette erreur est :
.BR
###<fonction> : }**← non← numeric← arg← : <argument>
.BR
dans lequel le nom de la fonction et l'argument incrimine sont imprimes.
.B 1
Un certain nombre de fonctions mathematiques ont ete "empruntees" a
la bibliotheque
|}FORTRAN (ex: les fonctions SQRT, SIN, ATAN ...). Ces fonctions
emetttent parfois des diagnostics d'erreurs qui leurs sont propres (par ex:
la tentative de calcul
de la racine carre d'un nombre negatif ...). Ces erreurs ne sont
pas fatales sous VLISP mais le resultat du calcul est bien evidemment
eronne.
.HL 1 Representation des nombres
La representation externe des nombres entiers est une suite de digits
dans la base de numeration courante. Cette base
est definie par les fonctions#:
.br
###(STATUS 5 <n>) en entree
.INDEX (|STATUS 5 n) base des nombres en entree
.BR
###(STATUS 6 <n>) en sortie
.INDEX (|STATUS 6 n) base des nombres en sortie
.BR
dans lesquelles <n> est un nombre compris entre 2 et 16.
Par defaut, la valeur de ces bases est de 10.
.B 1
Il existe un macro-caractere standard qui permet de lire
des S-expressions en supposant que tous les nombres qui
y sont inclus sont represente en octal, l'anti-slash }\ .
Il possede la definition suivante :
.NOFILL
.B 1
(DMC "\" ()
(PUSH (STATUS 5)) ; sauve l'ancienne base ;
(STATUS 5 8) ; base d'entree octale ;
(PROG1 ; puis lit une S-expression (qui ;
(READ) ; sera ramenee en valeur) et ;
(STATUS 5 (POP)))) ; restaure l'ancienne base ;
.B 1
ex : \(730 . 272) est equivalent a (472 . 186)
.B 1
.FILL
Les nombres entiers peuvent etre signes ou non.
Le traitement des signes est controle par des bits du r.g.#:
.BR
}bit← 12← du← r.g. en entree un nombre peut debuter par
le signe +
.br
}bit← 13← du← r.g. en entree un nombre peut debuter par
le signe -
.br
}bit← 22← du← r.g. en sortie les nombres positifs debutent par
le caractere -
.br
}bit← 23← du← r.g. en sortie les nombres negatifs debutent par
le caractere -
.b 1
Ces nombres sont stockes en memoire
sur un mot (de 36 bits); ils doivent donc etre compris dans l'intervalle
[#-2#←↑#35##, #+2#←↑#35#-#1#] c'est-a-dire [-34359738368#, +34359738367].
.B 1
La representation externe des nombres flottants est une suite de digits
decimaux suivie immediatement par un point decimal
( }. ) et suivie optionnellement
par une fraction decimale egalement. Pour garder une precision de 8 digits
un exposant peut etre rajoute en notation "E". Cette derniere forme
d'ecriture n'est toutefois disponible qu'en sortie actuellement. Les
nombres flottants sont stockes en memoire sur un mot (de 36 bits) qui
contient 1 bit de signe, 8 bits d'exposant et 27 bits de mantisse.
.B 1
Il n'existe a l'heure actuelle ni de nombres flottants "double precision",
ni de nombres complexes, ni de "Bignums".
.HL 1 Les test de type
.LM 5
.P -5,1,4
(NUMBP <s>) [SUBR a 1 argument]
.INDEX (|NUMBP s) |SUBR a 1 argument
.b 1
Cette fonction sert a tester si l'argument <s> est un nombre
de n'importe quel type.
si l'argument <s> est un nombre, NUMBP ramene <s> sinon NUMBP
ramene NIL.
.nofill
.b 1
ex : (NUMBP (ADD1 67)) -> 68
(NUMBP -56.89) -> -56.89
(NUMBP "Nan") -> NIL
.FILL
.P -5,2,4
(INUMBP <s>) [SUBR a 1 argument]
.INDEX (|INUMBP s) |SUBR a 1 argument
.B 1
teste si l'argument <s> est un "petit entier" i.e. un nombre entier
ayant une representation unique dans l'interprete.
Si <s> est un }petit← entier , INUMBP ramene ce nombre sinon INUMBP
ramene NIL. Cette fonction est principalement utilisee par le
compilateur pour ameliorer le code genere#: en effet
les comparaisons de petits entiers se font sur des adresses.
Le nombre de petits entiers
est determinee au moment de la generation du systeme VLISP.
D'une maniere standard tous les nombres entiers
dans l'intervale [-127 , +511] sont des petits entiers.
.nofill
.b 1
ex : (INUMBP 78) -> 78
(INUMBP -2558) -> NIL
(EQP 12 12) -> T (toujours, si 12 est un petit entier)
.FILL
.P -5,2,4
(FIXP <s>) [SUBR a 1 argument]
.INDEX (|FIXP s) |SUBR a 1 argument
.B 1
Cette fonction sert a tester si l'argument <s> est un nombre
entier. Si <s> est un nombre entier FIXP ramene ce nombre sinon
FIXP ramene NIL.
.NOFILL
.B 1
ex : (FIXP 78) -> 78
(FIXP -8878) -> -8878
(FIXP 12.2) -> NIL
.FILL
.P -5,2,4
(FLOATP <s>) [SUBR a 1 argument]
.INDEX (|FLOATP s) |SUBR a 1 argument
.B 1
Cette fonction sert a tester si l'argument <s> est un nombre
flottant. Si <s> est un nombre flottant FLOATP ramene ce nombre
sinon FLOATP ramene NIL.
.nofill
.b 1
ex : (FLOATP 100) -> NIL
(FLOATP 100.1) -> 100.1
.FILL
.P -5,2,4
(TYPNUMB <s>) [SUBR a 1 argument]
.INDEX (|TYPNUMB s) |SUBR a 1 argument
.B 1
cette fonction teste le type du nombre donne en argument et
ramene l'atome :
.BR
- FIX## si l'argument <n> est de type entier,
.BR
- FLOAT si l'argument <n> est de type flottant,
.BR
- NIL## si l'argument <n> n'est pas un nombre.
.NOFILL
.B 1
ex : (TYPNUMB 14) -> FIX
(TYPNUMB 14.4) -> FLOAT
(TYPNUMB "ou") -> NIL
.FILL
.LM 0
.HL 1 Les conversions
Ces fonctions testent si
leur argument est un nombre. Dans le cas ou il ne
l'est pas, une erreur apparait. Le libelle de cette erreur est :
.BR
###<fonction> : }**← non← numeric← arg← : <argument>
.BR
dans lequel le nom de la fonction et l'argument incrimine sont imprimes.
.LM 5
.P -5,2,4
(|}FIX <n>) [SUBR a 1 argument]
.INDEX (|FIX n) |SUBR a 1 argument
.B 1
convertit le nombre flottant <n> en son equivalent entier. Un calcul d'arrondi
est effectue automatiquement de la maniere suivante : la partie entiere est
incrementee de 1 si la partie fractionnaire est >= 0.5 (pour les nombres
negatifs le test est <= a 0.5 ).
.NOFILL
.b 1
EX : (FIX 3.14) -> 3
(FIX 3.98) -> 4
(FIX 3) -> 3
.FILL
.P -5,1 4
(|}FLOAT <n>) [SUBR a 1 argument]
.INDEX (|FLOAT n) SUBR a 1 argument
.B 1
convertit le nombre entier <n> en son equivalent flottant.
.NOFILL
.B 1
ex : (FLOAT 3) -> 3.
(FLOAT -2) -> -2.
(FLOAT 120000000) -> 1.2E8
(FLOAT 3.14) -> 3.14
.FILL
.LM 0
.HL 1 Arithmetique entiere
Les fonctions qui vont etre decrites utilisent des operandes
supposes de type entier. Ces fonctions n'effectuent aucun controle
de validite de type.
Si les arguments ne sont pas des nombres entiers, ces fonctions
livrent en general de bien etranges resultats. Toutefois un
calcul impossible povoque l'erreur **#arithmetic exception (voir
cette erreur).
.LM 5
.P -5,1,4
(ABS <n>) [SUBR a 1 argument]
.INDEX (|ABS n) |SUBR a 1 argument
.B 1
ramene la valeur absolue de l'argument <n>.
.NOFILL
.B1
ex : (ABS 10) -> 10
(ABS -10) -> 10
.FILL
.P -5,2,4
(ADD1 <n>) [SUBR a 1 argument]
.INDEX (|ADD1 n) |SUBR a 1 argument
.B 1
ramene la valeur : <n> + 1 .
.NOFILL
.B 1
ex : (ADD1 6) -> 7
(ADD1 -4) -> -3
.FILL
.P -5,2,4
(DIFFER <n1> ... <nN>) [SUBR a N arguments]
.INDEX (|DIFFER n1 ... nN) |SUBR a N arguments
.B 1
ramene la valeur : <n1> - <n2> - ... - <nN>
.NOFILL
.B 1
ex : (DIFFER 6) -> 6
(DIFFER 12 7 3) -> 2
.FILL
.P -5,2,4
(MAX <n1> ... <nN>) [SUBR a N arguments]
.INDEX (|MAX n1 ... nN) |SUBR a N arguments
.B 1
ramene la valeur maximum des <n1> ... <nN>.
.NOFILL
.B 1
ex : (MAX 1 3 5 3 1) -> 5
.NOFILL
.P -5,2,4
(MIN <n1> ... <nN>) [SUBR a N arguments]
.INDEX (|MIN n1 ... nN) |SUBR a N arguments
.B 1
ramene la valeur minimum des <n1> ... <nN>.
.NOFILL
.B 1
ex : (MIN 5 4 3 4 ) -> 3
.FILL
.P -5,2,4
(MINUS <n>) [SUBR a 1 argument]
.INDEX (|MINUS n) |SUBR a 1 argument
.B 1
ramene la valeur : - <n>
.NOFILL
.B 1
ex : (MINUS -10) -> 10
(MINUS 25) -> -25
.FILL
.P -5,2,4
(PLUS <n1> ... <nN>) [SUBR a N arguments]
.INDEX (|PLUS n1 ... nN) |SUBR a N arguments
.B 1
ramene la valeur : <n1> + <n2> + ... + <nN>
.NOFILL
.B 1
ex : (PLUS 5 6) -> 11
(PLUS 5 6 4) -> 15
.FILL
.P -5,2,4
(QUO <n1> ... <nN>) [SUBR a N arguments]
.INDEX (|QUO n1 ... nN) |SUBR a N arguments
.B 1
ramene la valeur du quotient de : <n1> / <n2> / ... / <nN>
.NOFILL
.B 1
ex : (QUO 20 5) -> 4
(QUO 40 4 2) -> 5
.FILL
.P -5,2,4
(REM <n1> <n2>) [SUBR a 2 arguments]
.INDEX (|REM n1 n2) |SUBR a 2 arguments
.B 1
ramene la valeur du reste de la division entiere de <n1> par <n2>.
.NOFILL
.B 1
ex : (REM 11 3) -> 2
(REM 14 22) -> 14
.FILL
.P -5,2,4
(SUB1 <n>) [SUBR a 1 argument]
.INDEX (|SUB1 n) |SUBR a 1 argument
.B 1
ramene la valeur : <n> - 1
.NOFILL
.b 1
ex : (SUB1 7) -> 6
(SUB1 -9) -> -10
.FILL
.P -5,2,4
(TIMES <n1> ... <nN>) [SUBR a N arguments]
.INDEX (|TIMES n1 ... nN) |SUBR a N arguments
.b 1
ramene la valeur : <n1> * <n2> * ... * <nN>
.NOFILL
.b 1
ex : (TIMES 10 4) -> 40
(TIMES 2 3 4) -> 24
.FILL
.lm 0
.HL 1 Comparaisons entieres
Ces fonctions n'effectuent aucun test de validite de type.
Si les arguments de ces fonctions ne sont pas des nombres, leurs
resultats ne sont pas significatifs. Elles ne provoquent jamais
d'erreur.
.LM 5
.P -5,2,4
(EQN <n1> <n2>) [SUBR a 2 arguments]
.INDEX (|EQN n1 n2) |SUBR a 2 arguments
.B 1
ramene <n1> si les 2 nombres <n1> et <n2> sont egaux, sinon EQN ramene NIL.
.B 1
.NOFILL
ex : (EQN 58 58) -> 58
(EQN 34 34.) -> NIL
(EQN 21963283741 21963283741.) -> 21963283741
(et c'est bien le seul cas d'egalite mixte!)
.FILL
.P -5,2,4
(EVENP <n>) [SUBR a 1 argument]
.INDEX (|EVENP n) |SUBR a 1 argument
.B 1
ramene <n> si <n> est pair. Si <n> est impair EVENP ramene NIL.
.NOFILL
.B 1
ex : (EVENP 4) -> 4
(EVENP -5) -> NIL
.FILL
.P -5,2,4
(GE <n1> <n2> ... <nN-1> <nN>) [SUBR a N arguments]
.INDEX (|GE n1 n2 ... nN) |SUBR a N arguments
.b 1
si <n1> >= <n2> >= ... >= <nN-1> >= <nN> alors GE ramene <nN-1>
sinon GE ramene NIL.
.NOFILL
.B 1
ex : (GE 3 7) -> NIL
(GE 7 7 4 3) -> 4
.FILL
.P -5,2,4
(GEZP <n>) [SUBR a 1 argument]
.INDEX (|GEZP n) |SUBR a 1 argument
.B 1
ramene <n> si <n> est plus grand ou egal a 0. Si <n> est plus
petit que 0 GEZP ramene NIL.
.NOFILL
.B 1
ex : (GEZP 5) -> 5
(GEZP 0) -> 0
(GEZP -5) -> NIL
.FILL
.P -5,2,4
(GT <n1> <n2> ... <nN-1> <nN>) [SUBR a N arguments]
.INDEX (|GT n1 n2 ... nN) |SUBR a N arguments
.b 1
si <n1> > <n2> > ... > <nN-1> > <nN> alors GT ramene <nN-1>
sinon GT ramene NIL.
.NOFILL
.B 1
ex : (GT 5 5) -> NIL
(GT 7 4 3) -> 4
.FILL
.P -5,2,4
(GZP <n>) [SUBR a 1 argument]
.INDEX (|GZP n) |SUBR a 1 argument
.B 1
ramene <n> si <n> est plus grand que 0. Si <n> est plus petit
ou egal a 0 GZP ramene NIL.
.NOFILL
.B 1
ex : (GZP 5) -> 5
(GZP 0) -> NIL
(GZP -5) -> NIL
.FILL
.P -5,2,4
(LE <n1> <n2> ... <nN-1> <nN>) [SUBR a N arguments]
.INDEX (|LE n1 n2 ... nN) |SUBR a N arguments
.b 1
si <n1> <= <n2> <= ... <= <nN-1> <= <nN> alors LE ramene <nN-1>
sinon LE ramene NIL.
.NOFILL
.B 1
ex : (LE 5 5) -> 5
(LE 4 4 6 9) -> 9
.FILL
.P -5,2,4
(LEZP <n>) [SUBR a 1 argument]
.INDEX (|LEZP n) |SUBR a 1 argument
.B 1
ramene <n> si <n> est plus petit ou egal a 0. Si <n> est plus
grand que 0 LEZP ramene NIL.
.NOFILL
.B 1
ex : (LEZP 5) -> NIL
(LEZP 0) -> 0
(LEZP -5) -> -5
.FILL
.P -5,2,4
(LT <n1> <n2> ... <nN-1> <nN>) [SUBR a N arguments]
.INDEX (|LT n1 n2 ... nN) |SUBR a N arguments
.b 1
si <n1> < <n2> < ... < <nN-1> < <nN> alors LT ramene <nN-1>
sinon LT ramene NIL.
.NOFILL
.B 1
ex : (LT 5 5) -> NIL
(LT 4 5 6) -> 5
.FILL
.P -5,2,4
(LZP <n>) [SUBR a 1 argument]
.INDEX (|LZP n) |SUBR a 1 argument
.B 1
ramene <n> si <n> est plus petit que 0. Si <n> ets plus grand ou
egal a 0 LZP ramene NIL.
.NOFILL
.B 1
ex : (LZP 5) -> NIL
(LZP 0) -> NIL
(LZP -5) -> -5
.FILL
.P -5,2,4
(NEQN <n1> <n2>) [SUBR a 2 arguments]
.INDEX (|NEQN n1 n2) |SUBR a 2 arguments
.B 1
ramene <n1> si les deux nombres <n1> et <n2> sont differents.
NEQN ramene NIL si les deux nombres sont egaux. Cette fonction
est equivalente a (NOT (EQN <n1> <n2>)).
.NOFILL
.B 1
ex : (NEQN 5 6) -> 5
(NEQN -3 -3) -> NIL
.FILL
.P -5,2,4
(NEROP <n>) [SUBR a 1 argument]
.INDEX (|NEROP n) |SUBR a 1 argument
.B 1
ramene <n> si <n> est different de 0. Si <n> egal 0 NEROP ramene NIL.
.NOFILL
.B 1
ex : (NEROP 5) -> 5
(NEROP 0) -> NIL
(NEROP -5) -> -5
.FILL
.P -5,2,4
(ODDP <n>) [SUBR a 1 argument]
.INDEX (|ODDP n) |SUBR a 1 argument
.B 1
ramene <n> si <n> est impair. Si <n> est pair ODDP ramene NIL.
.NOFILL
.B 1
ex : (ODDP -4) -> NIL
(ODDP -5) -> -5
.FILL
.P -5,2,4
(ZEROP <n>) [SUBR a 1 argument]
.INDEX (|ZEROP n) |SUBR a 1 argument
.B 1
ramene 0 si <n> est egal a 0 sinon ramene NIL.
.NOFILL
.B 1
ex : (ZEROP 5) -> NIL
(ZEROP 0) -> 0
(ZEROP -5) -> NIL
.FILL
.LM 0
.HL 1 Arithmetique mixte
Ces fonctions testent si
leurs arguments sont des nombres. Dans le cas ou ils ne
le sont pas, une erreur apparait. Le libelle de cette erreur est :
.BR
###<fonction> : }**← non← numeric← arg← : <argument>
.BR
dans lequel le nom de la fonction et l'argument incrimine sont imprimes.
.B 1
Ces arguments peuvent etre de n'importe
quel type : entier ou flottant. Si l'un des arguments est flottant, le resultat
sera un nombre flottant#; si tous les arguments sont de type entier, le resultat
sera un nombre entier. Il y a donc conversion automatique des arguments
avec priorite aux nombres flottants.
.LM 5
.P -5,2,4
(1+ <n>) [SUBR a 1 argument]
.INDEX (1+ n) |SUBR a 1 argument
.B 1
ramene la valeur : <n> + 1 .
.NOFILL
.B 1
ex : (1+ 3) -> 4
(1+ 1.2) -> 2.2
.FILL
.P -5,2,4
(1- <n>) [SUBR a 1 argument]
.INDEX (1- N) |SUBR a 1 argument
.B 1
ramene la valeur : <n> - 1 .
.NOFILL
.B 1
ex : (1- 3) -> 2
(1- 3.2) -> 2.2
.FILL
.P -5,2,4
(+ <n1> <n2>) [SUBR a 2 arguments]
.INDEX (+ n1 n2) |SUBR a 2 arguments
.B 1
ramene la somme des 2 arguments : <n1> + <n2> .
.NOFILL
.B 1
ex : (+ 2 3) -> 5
(+ 2 3.2) -> 5.2
(+ 2.3 3) -> 5.3
(+ 2.3 3.3) -> 5.6
.FILL
.P -5,2,4
(- <n1> <n2>) [SUBR a 2 arguments]
.INDEX (- n1 n2) |SUBR a 2 arguments
.B 1
ramene la difference des 2 arguments : <n1> - <n2> .
.NOFILL
.B 1
ex : (- 3 1) -> 2
(- 3 1.) -> 2.
(- 3.2 1.1) -> 2.1
.FILL
.P -5,2,4
(* <n1> <n2>) [SUBR a 2 arguments]
.INDEX (* n1 n2) |SUBR a 2 arguments
.B 1
ramene le produit des 2 arguments : <n1> * <n2> .
.NOFILL
.B 1
ex : (* 3 2) -> 6
(* 3 2.1) -> 6.3
(* 3. 2.2) -> 6.6
.FILL
.P -5,2,4
(// <n1> <n2>) [SUBR a 2 arguments]
.INDEX (// n1 n2) |SUBR a 2 arguments
.B 1
ramene le quotient des 2 arguments : <n1> // <n2> . Le caractere / est un
caractere special, il faut le doubler pour utiliser cette fonction :
on doit ecrire (// 3 2.) et non (/ 3 2.).
.NOFILL
.B 1
ex : (// 3 2) -> 1
(// 3 2.) -> 1.5
(// 1 3.) -> 0.3333333
.FILL
.P -5,2,4
(** <n1> <n2>) [SUBR a 2 arguments]
.INDEX (** n1 n2) |SUBR a 2 arguments
.B 1
ramene la valeur de l'evaluation de <n1> a la puissance <n2>.
.NOFILL
.B 1
ex : (** 2 3) -> 8
(** 2. 4) -> 16.
(** 2 5.) -> 32.
(** 2 0.5) -> 1.414214
(** 2 -0.5) -> 0.7071068
(** 15. 0) -> 1.
.FILL
.P -5,2,4
(/\ <n1> <n2>) [SUBR a 2 arguments]
.INDEX (/\ n1 n2) |SUBR a 2 arguments
.B 1
ramene le reste de la division de <n1> et <n2>. Cette fonction est utilisee
en general avec des arguments entiers pour ramener la valeur du reste
d'une division entiere
(la fonction |}MODULO ). Le caractere \ etant un macro-caractere, il faut
le faire preceder du caractere / (quote caractere) pour utiliser cette fonction.
On doit ecrire (/\ 5 3) et non (\ 5 3) .
.NOFILL
.B 1
ex : (/\ 5 3) -> 2
(/\ 5. 3.) -> 2.980232E-8
.FILL
.LM 0
.HL 1 Comparaisons mixtes
Ces fonctions testent si leurs deux arguments sont des nombres.
Dans le cas ou ils ne le seraient pas, une erreur apparait.
Le libelle de cette erreur est :
.BR
### <fonction> }**← non← numeric← arg← : <argument>
.BR
dans lequel le nom de la fonction et l'argument incrimine sont
imprimes.
.B 1
Si les deux arguments sont de type entier, ces fonctions effectuent
des comparaisons entieres (elles sont donc equivalentes aux fonctions
de comparaison entieres), si au moins un des arguments est flottat,
les comparaisons s'operent en flottant apres conversion, si
necessaire de l'autre argument.
.LM 5
.P -5,2,4
(= <n1> <n2>) [SUBR a 2 arguments]
.INDEX (= n1 n2) |SUBR a 2 arguments
.B 1
ramene <n1> si <n1> et <n2> sont egaux. Si <n1> est different de <n2>
= ramene NIL.
.nofill
.b 1
ex : (= 378 378.) -> 378.
(= 22 23) -> NIL
.FILL
.P -5,2,4
(←# <n1> <n2>) [SUBR a 2 arguments]
.INDEX (←# n1 n2) |SUBR a 2 arguments
.B 1
ramene <n1> si <n1> est different de <n2>. Si <n1> egal <n2>, ←#
ramene NIL.
.NOFILL
.B 1
ex : (←# 327.12 312) -> 327.12
(←# 22.0 22) -> NIL
.FILL
.P -5,2,4
(> <n1> <n2>) [SUBR a 2 arguments]
.INDEX (←> n1 n2) |SUBR a 2 arguments
.B 1
ramene <n1> si <n1> est superieur a <n2>. Si <n1> est inferieur
ou egal a <n2>, > rameme NIL.
.nofill
.b 1
ex : (> 327.12 327) -> 327.12
(> 327 327.1) -> NIL
.Fill
.P -5,2,4
(>= <n1> <n2>) [SUBR a 2 arguments]
.INDEX (←>= n1 n2) |SUBR a 2 arguments
.B 1
ramene <n1> si <n1> est superieur ou egal a <n2>. Si <n1> est inferieur
a <n2>, >= rameme NIL.
.nofill
.b 1
ex : (>= 327. 327) -> 327.
(>= 327 327.1) -> NIL
.Fill
.P -5,2,4
(<= <n1> <n2>) [SUBR a 2 arguments]
.INDEX (←<= n1 n2) |SUBR a 2 arguments
.B 1
ramene <n1> si <n1> est inferieur ou egal a <n2>. Si <n1> est superieur
a <n2>, >= rameme NIL.
.nofill
.b 1
ex : (<= 327. 327) -> NIL
(<= 327 327.1) -> 327
.Fill
.P -5,2,4
(< <n1> <n2>) [SUBR a 2 arguments]
.INDEX (←< n1 n2) |SUBR a 2 arguments
.B 1
ramene <n1> si <n1> est inferieur a <n2>. Si <n1> est superieur
ou egal a <n2>, < rameme NIL.
.nofill
.b 1
ex : (< 327.12 327) -> NIL
(< 327 327.1) -> 327
.Fill
.LM 0
.HL 1 Fonctions logiques
Pour toutes les fonctions qui vont etre decrites, l'argument s'il existe
doit etre de type entier. Il n'y a pas de conversion automatique.
Ces fonctions ne provoquent jamais d'erreur.
.LM 5
.P -5,1,4
(COMPL <n>) [SUBR a 1 argument]
.INDEX (|COMPL n) |SUBR a 1 argument
.B 1
ramene la valeur du complement logique de <n>
.NOFILL
.B 1
ex : (COMPL 0) -> -1
(COMPL -2) -> 1
.FILL
.P -5,2,4
(LOGAND <n1> <n2>) [SUBR a 2 arguments]
.INDEX (|LOGAND n1 n2) |SUBR a 2 arguments
.B 1
Effectue l'operation de ET logique entre les deux operandes
<n1> et <n2>.
(LOGAND <n1> <n2>) et equivalent a l'ancienne ecriture :
(BOOLE 5 <n1> <n2>).
.NOFILL
.B 1
ex : (LOGAND \36 \25) -> \24
.FILL
.P -5,2,4
(LOGSHIFT <n1> <n2>) [SUBR a 2 arguments]
.INDEX (|LOGSHIFT n1 n2) |SUBR a 2 arguments
.B 1
Effectue un decalage logique de la valeur <n1>, <n2> fois.
Si <n2> est >0 un decalage gauche s'effectue, dans le cas
contraire (<n2> < 0), le decalage s'effectue a droite.
.NOFILL
.B 1
ex : (LOGSHIFT 8 3) -> 64
(LOGSHIFT 8 -2) -> 2
.FILL
.P -5,2,4
(LOGOR <n1> <n2>) [SUBR a 2 arguments]
.INDEX (|LOGOR n1 n2) |SUBR a 2 arguments
.B 1
Effectue l'operation de OU logique entre les deux operandes
<n1> et <n2>.
(LOGOR <n1> <n2>) est equivalent a l'ancienne ecriture :
(BOOLE 1 <n1> <n2>).
.NOFILL
.B 1
ex : (LOGOR \15 \7) -> \17
.FILL
.P -5,2,4
(LOGXOR <n1> <n2>) [SUBR a 2 arguments]
.INDEX (|LOGXOR n1 n2) |SUBR a 2 arguements
.B 1
Effectue l'operation de OU exclusif logique entre les deux
operandes <n1> et <n2>.
(LOGXOR <n1> <n2>) et equivalent a l'ancienne ecriture :
(BOOLE 9 <n1> <n2>).
.NOFILL
.B 1
ex : (LOGXOR 5 3) -> 6
.FILL
.P -5,2,4
(SWAP <n>) [SUBR a 1 argument]
.INDEX (|SWAP n) |SUBR a 1 argument
.B 1
ramene la valeur resultant de l'echange des 18 bits de
droite avec les 18 bits de gauche de <n>.
.NOFILL
.B 1
ex: (SWAP \177333001) -> \333001000177
.FILL
.LM 0
.HL 1 Fonctions mathematiques
Pour toutes les fonctions qui vont etre decrites, l'argument s'il existe
doit etre de type flottant. Il n'y a pas de conversion automatique.
.LM 5
.P -5,2,4
(SQRT <n>) [SUBR a 1 argument]
.INDEX (|SQRT n) |SUBR a 1 argument
.B 1
ramene la racine carree du nombre <n>. <n> doit etre un nombre flottant
positif.
.NOFILL
.B 1
ex : (SQRT 25.) -> 5.
(SQRT 5.) -> 2.236068
(SQRT -5.) ->
%FRSLIB attempt to take SQRT of negative arg= 2.236068
.FILL
.P -5,2,4
(SIN <n>) [SUBR a 1 argument]
.INDEX (|SIN n) |SUBR a 1 argument
.B 1
ramene la valeur du sinus de l'angle <n> exprime en radians.
.P -5,2,4
(COS <n>) [SUBR a 1 argument]
.INDEX (|COS n) |SUBR a 1 argument
.B 1
ramene la valeur du cosinus de l'angle <n> exprime en radians.
.P -5,2,4
(ATAN <n>) [SUBR a 1 argument]
.INDEX (|ATAN n) |SUBR a 1 argument
.B 1
ramene la valeur de la fonction arc tangente, c'est-a-dire la valeur
de l'angle (en radians) dont la tangente est <n>.
.NOFILL
.B 1
; exemples d'utilisation des fonctions trigonometriques ;
.B 1
(SETQ PI 3.14159) -> 3.14159
(SETQ PI:2 (// PI 2)) -> 1.570795
(SETQ PI:4 (// PI 4)) -> 0.7853975
.B 1
(SIN 0.) -> 0
(SIN PI:4) -> 0.7071063
(SIN PI:2) -> 1.
.B 1
(COS 0.) -> 1.
(COS PI:4) -> 0.7071072
(COS PI:2) -> 1.334181E-6
.B 1
(SETQ X 1.2) -> 1.2
.B 1
(SQRT (+ (** (SIN X) 2) (** (COS X) 2))) -> 1.
.B 1
; la fonction TANGENTE n'est pas standard : definissons-la ;
.B 1
(DE TANG (X)
(// (SIN X) (COS X))) -> TANG
.B 1
(TANG 0.) -> 0
(TANG PI:4) -> 0.9999987
(TANG PI:2) -> 749523.3
.B 1
(ATAN 0.) -> 0
(ATAN 1.) -> 0.7853982
(ATAN (TANG 1.123)) -> 1.123
.FILL
.P -5,2,4
(EXP <n>) [SUBR a 1 argument]
.INDEX (|EXP n) |SUBR a 1 argument
.B 1
ramene la valeur e puissance <n>.
.NOFILL
.B 1
ex : (EXP 0) -> 1.
(EXP 1.) -> 2.718282
.FILL
.P -5,2,4
(LOG <n>) [SUBR a 1 argument]
.INDEX (|LOG n) |SUBR a 1 argument
.B 1
ramene la valeur du logarithme neperien de <n>.
.NOFILL
.B 1
ex : (LOG 1.) -> 0
(LOG 2.718282) -> 1.
.FILL
.P -5,2,4
(LOG10 <n>) [SUBR a 1 argument]
.INDEX (|LOG10 n) |SUBR a 1 argument
.B 1
ramene la valeur du logarithme decimal de <n>.
.NOFILL
.B 1
ex : (LOG10 1.) -> 0
(LOG10 10.) -> 1.
(LOG10 20.) -> 1.30103
(LOG10 100.) -> 2.
.FILL
.P -5,2,4
(RANDOM ) [SUBR a 0 argument]
.INDEX (|RANDOM) |SUBR a 0 argument
.B 1
ramene a chaque appel un nombre flottant, aleatoire, compris
dans l'intervalle ]0. , 1.[.
.NOFILL
.B 1
ex : (RANDOM) -> 0.1948187
(RANDOM) -> 0.7324636
(RANDOM) -> 0.6087399
.FILL
.LM 0
.COMMENT ---------- Manuel VLISP 10 . 3 ----- Standard -----
.IF PART
.DO INDEX Table d'INDEX du chapitre 4
.ENDIF PART
.COMMENT ---------- Manuel VLISP 10 . 3 ----- Standard -----